/*
 * Octobrite Test
 * 7/1/2009 - yergacheffe@atomsandelectrons.com
 * 
 * Cycles through a series of colors by linear interpolation
 * which gives a nice fading effect. There are multiple
 * interpolation modes which affect how the colors progress
 * through the 8 LEDs.
 */

// Color channel constants
#define RED 0
#define GREEN 1
#define BLUE 2

// TLC5947 maintains 12 bits of grayscale per LED channel
#define CHANNEL_BITS 12
#define CHANNEL_MAX (long)( (1<<CHANNEL_BITS) - 1)

// TLC5947 pins
int SIN_PIN = 13;
int SCLK_PIN = 12;
int BLANK_PIN = 11;
int XLAT_PIN = 10;

// Interpolation constants
#define INTERPOLATION_MODE_SHIFT      0
#define INTERPOLATION_MODE_CENTEROUT  1
#define INTERPOLATION_MODE_COMB       2
#define INTERPOLATION_MODE_RAINBOW    3

int lerpsteps = 50;
int stepdelay = 50;
int lerpindex = 0;
int interpolationMode = INTERPOLATION_MODE_CENTEROUT;
unsigned int framecounter = 0;

// Color table and current/prev color state. The interpolation looks
// best when only one channel is changing during an interpolation
// between a pair of adjacent colors. The intensity ranges from 0..100
// but intensities of 4 or 5 are plenty bright and draw way less current.
int colorCount = 10;
int clutred[10] =   { 5, 0, 0, 0, 5, 0, 0, 5, 5, 0};
int clutgreen[10] = { 0, 0, 0, 0, 0, 0, 4, 4, 0, 5};
int clutblue[10] =  { 0, 0, 7, 0, 7, 0, 0, 0, 5, 5};
int currentColorIndex = 0;
int previousColor[3];
int currentColor[3];
int colorHistory[8][3];

void setup()
{
  // Setup TLC5947 pins
   pinMode(SIN_PIN, OUTPUT);
   pinMode(SCLK_PIN, OUTPUT);
   pinMode(BLANK_PIN, OUTPUT);
   pinMode(XLAT_PIN, OUTPUT);

   // Turn off all LEDs
   digitalWrite(BLANK_PIN, HIGH);
   
   // Default state for clock and data latch
   digitalWrite(SCLK_PIN, LOW);
   digitalWrite(XLAT_PIN, LOW);
      
   // Init comms for debug info
   Serial.begin(9600);
   
   // Reset color state
   currentColor[RED]   = clutred[currentColorIndex];
   currentColor[GREEN] = clutgreen[currentColorIndex];
   currentColor[BLUE]  = clutblue[currentColorIndex];
   NextColor();
   
   // And write the colors to the octobrite
   WriteColors();
   
   // Finally enable the LEDs
   digitalWrite(BLANK_PIN, LOW);
}

// Called when we've completed an interpolation between a pair of
// colors. This sets us up to interpolate to the next color in
// the lookup table
void NextColor()
{
  // We've finished interpolating to the current color, so it becomes the
  // previoud color we're interpolating from
  previousColor[RED]   = currentColor[RED];  
  previousColor[GREEN] = currentColor[GREEN];  
  previousColor[BLUE]  = currentColor[BLUE];
  
  // And pick the next color in the CLUT for the current color
  currentColorIndex = (currentColorIndex + 1) % colorCount;
  lerpindex = 0;
  currentColor[RED]   = clutred[currentColorIndex];
  currentColor[GREEN] = clutgreen[currentColorIndex];
  currentColor[BLUE]  = clutblue[currentColorIndex];
}

// Writes out a single 12-bit grayscale channel
void WriteChannel(int value)
{
  int bit;
  
  // Write value, MSB first
  for (bit=11; bit>=0; --bit)
  {
    if (value & (1<<bit))
    {
      digitalWrite(SIN_PIN, HIGH);
    }
    else
    {
      digitalWrite(SIN_PIN, LOW);
    }
    
    // We need to wait 30ns after writing data before clocking it in.
    // Fortunately, our AVR is slow enough that we don't need to 
    // do an explicit wait here
    digitalWrite(SCLK_PIN, HIGH);
    digitalWrite(SCLK_PIN, LOW);
  }
}

void WriteColors()
{
  // First calculate the current interpolated color value
  long red   = (CHANNEL_MAX*previousColor[RED]*(lerpsteps-lerpindex)   + CHANNEL_MAX*currentColor[RED]*lerpindex) / lerpsteps;
  long green = (CHANNEL_MAX*previousColor[GREEN]*(lerpsteps-lerpindex) + CHANNEL_MAX*currentColor[GREEN]*lerpindex) / lerpsteps;
  long blue  = (CHANNEL_MAX*previousColor[BLUE]*(lerpsteps-lerpindex)  + CHANNEL_MAX*currentColor[BLUE]*lerpindex) / lerpsteps;
  
  red = red / 100;
  green = green / 100;
  blue = blue / 100;
  
  // And save in history buffer
  int index=0;
  {
    for (index=7; index>0; --index)
    {
      colorHistory[index][0] = colorHistory[index-1][0];
      colorHistory[index][1] = colorHistory[index-1][1];
      colorHistory[index][2] = colorHistory[index-1][2];
    }
    colorHistory[0][0] = red;
    colorHistory[0][1] = green;
    colorHistory[0][2] = blue;
  }
  
  // Disbaled debug output
  if (false)
  {
    Serial.print("RGB=(");
    Serial.print(red);
    Serial.print(", ");
    Serial.print(green);
    Serial.print(", ");
    Serial.print(blue);
    Serial.println(")");
  }
  
   if (interpolationMode == INTERPOLATION_MODE_SHIFT)
   {
     // Now write the next RGB value, which will shift the colors
     // down along the other LEDs
     WriteChannel(blue);
     WriteChannel(green);
     WriteChannel(red);
   }
   else if (interpolationMode == INTERPOLATION_MODE_CENTEROUT)
   {
     // For this one we need to update all 8 LEDs
     for (index=3; index>=0; --index)
     {
       WriteChannel(colorHistory[index][0]);
       WriteChannel(colorHistory[index][1]);
       WriteChannel(colorHistory[index][2]);
     }
     for (index=0; index<=3; ++index)
     {
       WriteChannel(colorHistory[index][0]);
       WriteChannel(colorHistory[index][1]);
       WriteChannel(colorHistory[index][2]);
     }
   }
   else if (interpolationMode == INTERPOLATION_MODE_COMB)
   {
     for (index=0; index<=3; ++index)
     {
       WriteChannel(colorHistory[0][0]); 
       WriteChannel(colorHistory[0][1]); 
       WriteChannel(colorHistory[0][2]); 
       
       WriteChannel(CHANNEL_MAX*previousColor[RED]/100);
       WriteChannel(CHANNEL_MAX*previousColor[GREEN]/100);
       WriteChannel(CHANNEL_MAX*previousColor[BLUE]/100);
     }
   }
   
   // Finally latch in the new color values
   digitalWrite(XLAT_PIN, HIGH);
   delay(1);
   digitalWrite(XLAT_PIN, LOW);
}



void loop()
{
  // Step the interpolation by one frame
  ++lerpindex;
  if (lerpindex > lerpsteps)
  {
    // We finished the interpolation between the current
    // color pair. Set up the next color pair.
    NextColor();
  }
  
  // Update the LEDs
  WriteColors();

  // Throttle the animation
  delay(stepdelay);
}